
%{
static Tcl_Obj* TclCallBack_defrSetArrayNameCbk=0;
 int _cbwrap_defrSetArrayNameCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetArrayNameCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetArrayNameCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetArrayNameCbk) void register_defrSetArrayNameCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetArrayNameCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetArrayNameCbk)Tcl_DecrRefCount(TclCallBack_defrSetArrayNameCbk);
    TclCallBack_defrSetArrayNameCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetArrayNameCbk(_cbwrap_defrSetArrayNameCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetAssertionCbk=0;
 int _cbwrap_defrSetAssertionCbk(defrCallbackType_e cbkType,defiAssertion * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetAssertionCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetAssertionCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiAssertion",SWIGTYPE_p_defiAssertion,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetAssertionCbk) void register_defrSetAssertionCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetAssertionCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetAssertionCbk)Tcl_DecrRefCount(TclCallBack_defrSetAssertionCbk);
    TclCallBack_defrSetAssertionCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetAssertionCbk(_cbwrap_defrSetAssertionCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetAssertionsStartCbk=0;
 int _cbwrap_defrSetAssertionsStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetAssertionsStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetAssertionsStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetAssertionsStartCbk) void register_defrSetAssertionsStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetAssertionsStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetAssertionsStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetAssertionsStartCbk);
    TclCallBack_defrSetAssertionsStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetAssertionsStartCbk(_cbwrap_defrSetAssertionsStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetAssertionsEndCbk=0;
 int _cbwrap_defrSetAssertionsEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetAssertionsEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetAssertionsEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetAssertionsEndCbk) void register_defrSetAssertionsEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetAssertionsEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetAssertionsEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetAssertionsEndCbk);
    TclCallBack_defrSetAssertionsEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetAssertionsEndCbk(_cbwrap_defrSetAssertionsEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetBlockageCbk=0;
 int _cbwrap_defrSetBlockageCbk(defrCallbackType_e cbkType,defiBlockage * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetBlockageCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetBlockageCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiBlockage",SWIGTYPE_p_defiBlockage,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetBlockageCbk) void register_defrSetBlockageCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetBlockageCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetBlockageCbk)Tcl_DecrRefCount(TclCallBack_defrSetBlockageCbk);
    TclCallBack_defrSetBlockageCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetBlockageCbk(_cbwrap_defrSetBlockageCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetBlockageStartCbk=0;
 int _cbwrap_defrSetBlockageStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetBlockageStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetBlockageStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetBlockageStartCbk) void register_defrSetBlockageStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetBlockageStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetBlockageStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetBlockageStartCbk);
    TclCallBack_defrSetBlockageStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetBlockageStartCbk(_cbwrap_defrSetBlockageStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetBlockageEndCbk=0;
 int _cbwrap_defrSetBlockageEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetBlockageEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetBlockageEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetBlockageEndCbk) void register_defrSetBlockageEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetBlockageEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetBlockageEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetBlockageEndCbk);
    TclCallBack_defrSetBlockageEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetBlockageEndCbk(_cbwrap_defrSetBlockageEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetBusBitCbk=0;
 int _cbwrap_defrSetBusBitCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetBusBitCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetBusBitCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetBusBitCbk) void register_defrSetBusBitCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetBusBitCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetBusBitCbk)Tcl_DecrRefCount(TclCallBack_defrSetBusBitCbk);
    TclCallBack_defrSetBusBitCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetBusBitCbk(_cbwrap_defrSetBusBitCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetCannotOccupyCbk=0;
 int _cbwrap_defrSetCannotOccupyCbk(defrCallbackType_e cbkType,defiSite * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetCannotOccupyCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetCannotOccupyCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiSite",SWIGTYPE_p_defiSite,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetCannotOccupyCbk) void register_defrSetCannotOccupyCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetCannotOccupyCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetCannotOccupyCbk)Tcl_DecrRefCount(TclCallBack_defrSetCannotOccupyCbk);
    TclCallBack_defrSetCannotOccupyCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetCannotOccupyCbk(_cbwrap_defrSetCannotOccupyCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetCanplaceCbk=0;
 int _cbwrap_defrSetCanplaceCbk(defrCallbackType_e cbkType,defiSite * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetCanplaceCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetCanplaceCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiSite",SWIGTYPE_p_defiSite,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetCanplaceCbk) void register_defrSetCanplaceCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetCanplaceCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetCanplaceCbk)Tcl_DecrRefCount(TclCallBack_defrSetCanplaceCbk);
    TclCallBack_defrSetCanplaceCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetCanplaceCbk(_cbwrap_defrSetCanplaceCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetCaseSensitiveCbk=0;
 int _cbwrap_defrSetCaseSensitiveCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetCaseSensitiveCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetCaseSensitiveCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetCaseSensitiveCbk) void register_defrSetCaseSensitiveCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetCaseSensitiveCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetCaseSensitiveCbk)Tcl_DecrRefCount(TclCallBack_defrSetCaseSensitiveCbk);
    TclCallBack_defrSetCaseSensitiveCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetCaseSensitiveCbk(_cbwrap_defrSetCaseSensitiveCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetComponentCbk=0;
 int _cbwrap_defrSetComponentCbk(defrCallbackType_e cbkType,defiComponent * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetComponentCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetComponentCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiComponent",SWIGTYPE_p_defiComponent,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetComponentCbk) void register_defrSetComponentCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetComponentCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetComponentCbk)Tcl_DecrRefCount(TclCallBack_defrSetComponentCbk);
    TclCallBack_defrSetComponentCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetComponentCbk(_cbwrap_defrSetComponentCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetComponentExtCbk=0;
 int _cbwrap_defrSetComponentExtCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetComponentExtCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetComponentExtCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetComponentExtCbk) void register_defrSetComponentExtCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetComponentExtCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetComponentExtCbk)Tcl_DecrRefCount(TclCallBack_defrSetComponentExtCbk);
    TclCallBack_defrSetComponentExtCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetComponentExtCbk(_cbwrap_defrSetComponentExtCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetComponentStartCbk=0;
 int _cbwrap_defrSetComponentStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetComponentStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetComponentStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetComponentStartCbk) void register_defrSetComponentStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetComponentStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetComponentStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetComponentStartCbk);
    TclCallBack_defrSetComponentStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetComponentStartCbk(_cbwrap_defrSetComponentStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetComponentEndCbk=0;
 int _cbwrap_defrSetComponentEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetComponentEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetComponentEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetComponentEndCbk) void register_defrSetComponentEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetComponentEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetComponentEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetComponentEndCbk);
    TclCallBack_defrSetComponentEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetComponentEndCbk(_cbwrap_defrSetComponentEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetConstraintCbk=0;
 int _cbwrap_defrSetConstraintCbk(defrCallbackType_e cbkType,defiAssertion * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetConstraintCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetConstraintCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiAssertion",SWIGTYPE_p_defiAssertion,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetConstraintCbk) void register_defrSetConstraintCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetConstraintCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetConstraintCbk)Tcl_DecrRefCount(TclCallBack_defrSetConstraintCbk);
    TclCallBack_defrSetConstraintCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetConstraintCbk(_cbwrap_defrSetConstraintCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetConstraintsStartCbk=0;
 int _cbwrap_defrSetConstraintsStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetConstraintsStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetConstraintsStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetConstraintsStartCbk) void register_defrSetConstraintsStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetConstraintsStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetConstraintsStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetConstraintsStartCbk);
    TclCallBack_defrSetConstraintsStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetConstraintsStartCbk(_cbwrap_defrSetConstraintsStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetConstraintsEndCbk=0;
 int _cbwrap_defrSetConstraintsEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetConstraintsEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetConstraintsEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetConstraintsEndCbk) void register_defrSetConstraintsEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetConstraintsEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetConstraintsEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetConstraintsEndCbk);
    TclCallBack_defrSetConstraintsEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetConstraintsEndCbk(_cbwrap_defrSetConstraintsEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetDefaultCapCbk=0;
 int _cbwrap_defrSetDefaultCapCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetDefaultCapCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetDefaultCapCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetDefaultCapCbk) void register_defrSetDefaultCapCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetDefaultCapCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetDefaultCapCbk)Tcl_DecrRefCount(TclCallBack_defrSetDefaultCapCbk);
    TclCallBack_defrSetDefaultCapCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetDefaultCapCbk(_cbwrap_defrSetDefaultCapCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetDesignCbk=0;
 int _cbwrap_defrSetDesignCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetDesignCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetDesignCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetDesignCbk) void register_defrSetDesignCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetDesignCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetDesignCbk)Tcl_DecrRefCount(TclCallBack_defrSetDesignCbk);
    TclCallBack_defrSetDesignCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetDesignCbk(_cbwrap_defrSetDesignCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetDesignEndCbk=0;
 int _cbwrap_defrSetDesignEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetDesignEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetDesignEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetDesignEndCbk) void register_defrSetDesignEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetDesignEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetDesignEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetDesignEndCbk);
    TclCallBack_defrSetDesignEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetDesignEndCbk(_cbwrap_defrSetDesignEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetDieAreaCbk=0;
 int _cbwrap_defrSetDieAreaCbk(defrCallbackType_e cbkType,defiBox * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetDieAreaCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetDieAreaCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiBox",SWIGTYPE_p_defiBox,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetDieAreaCbk) void register_defrSetDieAreaCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetDieAreaCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetDieAreaCbk)Tcl_DecrRefCount(TclCallBack_defrSetDieAreaCbk);
    TclCallBack_defrSetDieAreaCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetDieAreaCbk(_cbwrap_defrSetDieAreaCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetDividerCbk=0;
 int _cbwrap_defrSetDividerCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetDividerCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetDividerCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetDividerCbk) void register_defrSetDividerCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetDividerCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetDividerCbk)Tcl_DecrRefCount(TclCallBack_defrSetDividerCbk);
    TclCallBack_defrSetDividerCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetDividerCbk(_cbwrap_defrSetDividerCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetExtensionCbk=0;
 int _cbwrap_defrSetExtensionCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetExtensionCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetExtensionCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetExtensionCbk) void register_defrSetExtensionCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetExtensionCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetExtensionCbk)Tcl_DecrRefCount(TclCallBack_defrSetExtensionCbk);
    TclCallBack_defrSetExtensionCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetExtensionCbk(_cbwrap_defrSetExtensionCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetFillCbk=0;
 int _cbwrap_defrSetFillCbk(defrCallbackType_e cbkType,defiFill * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetFillCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetFillCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiFill",SWIGTYPE_p_defiFill,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetFillCbk) void register_defrSetFillCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetFillCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetFillCbk)Tcl_DecrRefCount(TclCallBack_defrSetFillCbk);
    TclCallBack_defrSetFillCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetFillCbk(_cbwrap_defrSetFillCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetFillStartCbk=0;
 int _cbwrap_defrSetFillStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetFillStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetFillStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetFillStartCbk) void register_defrSetFillStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetFillStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetFillStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetFillStartCbk);
    TclCallBack_defrSetFillStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetFillStartCbk(_cbwrap_defrSetFillStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetFillEndCbk=0;
 int _cbwrap_defrSetFillEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetFillEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetFillEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetFillEndCbk) void register_defrSetFillEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetFillEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetFillEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetFillEndCbk);
    TclCallBack_defrSetFillEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetFillEndCbk(_cbwrap_defrSetFillEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetFPCCbk=0;
 int _cbwrap_defrSetFPCCbk(defrCallbackType_e cbkType,defiFPC * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetFPCCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetFPCCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiFPC",SWIGTYPE_p_defiFPC,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetFPCCbk) void register_defrSetFPCCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetFPCCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetFPCCbk)Tcl_DecrRefCount(TclCallBack_defrSetFPCCbk);
    TclCallBack_defrSetFPCCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetFPCCbk(_cbwrap_defrSetFPCCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetFPCStartCbk=0;
 int _cbwrap_defrSetFPCStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetFPCStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetFPCStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetFPCStartCbk) void register_defrSetFPCStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetFPCStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetFPCStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetFPCStartCbk);
    TclCallBack_defrSetFPCStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetFPCStartCbk(_cbwrap_defrSetFPCStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetFPCEndCbk=0;
 int _cbwrap_defrSetFPCEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetFPCEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetFPCEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetFPCEndCbk) void register_defrSetFPCEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetFPCEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetFPCEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetFPCEndCbk);
    TclCallBack_defrSetFPCEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetFPCEndCbk(_cbwrap_defrSetFPCEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetFloorPlanNameCbk=0;
 int _cbwrap_defrSetFloorPlanNameCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetFloorPlanNameCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetFloorPlanNameCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetFloorPlanNameCbk) void register_defrSetFloorPlanNameCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetFloorPlanNameCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetFloorPlanNameCbk)Tcl_DecrRefCount(TclCallBack_defrSetFloorPlanNameCbk);
    TclCallBack_defrSetFloorPlanNameCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetFloorPlanNameCbk(_cbwrap_defrSetFloorPlanNameCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetGcellGridCbk=0;
 int _cbwrap_defrSetGcellGridCbk(defrCallbackType_e cbkType,defiGcellGrid * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetGcellGridCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetGcellGridCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiGcellGrid",SWIGTYPE_p_defiGcellGrid,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetGcellGridCbk) void register_defrSetGcellGridCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetGcellGridCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetGcellGridCbk)Tcl_DecrRefCount(TclCallBack_defrSetGcellGridCbk);
    TclCallBack_defrSetGcellGridCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetGcellGridCbk(_cbwrap_defrSetGcellGridCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetGroupNameCbk=0;
 int _cbwrap_defrSetGroupNameCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetGroupNameCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetGroupNameCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetGroupNameCbk) void register_defrSetGroupNameCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetGroupNameCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetGroupNameCbk)Tcl_DecrRefCount(TclCallBack_defrSetGroupNameCbk);
    TclCallBack_defrSetGroupNameCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetGroupNameCbk(_cbwrap_defrSetGroupNameCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetGroupMemberCbk=0;
 int _cbwrap_defrSetGroupMemberCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetGroupMemberCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetGroupMemberCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetGroupMemberCbk) void register_defrSetGroupMemberCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetGroupMemberCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetGroupMemberCbk)Tcl_DecrRefCount(TclCallBack_defrSetGroupMemberCbk);
    TclCallBack_defrSetGroupMemberCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetGroupMemberCbk(_cbwrap_defrSetGroupMemberCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetGroupCbk=0;
 int _cbwrap_defrSetGroupCbk(defrCallbackType_e cbkType,defiGroup * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetGroupCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetGroupCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiGroup",SWIGTYPE_p_defiGroup,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetGroupCbk) void register_defrSetGroupCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetGroupCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetGroupCbk)Tcl_DecrRefCount(TclCallBack_defrSetGroupCbk);
    TclCallBack_defrSetGroupCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetGroupCbk(_cbwrap_defrSetGroupCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetGroupExtCbk=0;
 int _cbwrap_defrSetGroupExtCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetGroupExtCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetGroupExtCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetGroupExtCbk) void register_defrSetGroupExtCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetGroupExtCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetGroupExtCbk)Tcl_DecrRefCount(TclCallBack_defrSetGroupExtCbk);
    TclCallBack_defrSetGroupExtCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetGroupExtCbk(_cbwrap_defrSetGroupExtCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetGroupsStartCbk=0;
 int _cbwrap_defrSetGroupsStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetGroupsStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetGroupsStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetGroupsStartCbk) void register_defrSetGroupsStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetGroupsStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetGroupsStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetGroupsStartCbk);
    TclCallBack_defrSetGroupsStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetGroupsStartCbk(_cbwrap_defrSetGroupsStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetGroupsEndCbk=0;
 int _cbwrap_defrSetGroupsEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetGroupsEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetGroupsEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetGroupsEndCbk) void register_defrSetGroupsEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetGroupsEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetGroupsEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetGroupsEndCbk);
    TclCallBack_defrSetGroupsEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetGroupsEndCbk(_cbwrap_defrSetGroupsEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetHistoryCbk=0;
 int _cbwrap_defrSetHistoryCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetHistoryCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetHistoryCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetHistoryCbk) void register_defrSetHistoryCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetHistoryCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetHistoryCbk)Tcl_DecrRefCount(TclCallBack_defrSetHistoryCbk);
    TclCallBack_defrSetHistoryCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetHistoryCbk(_cbwrap_defrSetHistoryCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetIOTimingCbk=0;
 int _cbwrap_defrSetIOTimingCbk(defrCallbackType_e cbkType,defiIOTiming * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetIOTimingCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetIOTimingCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiIOTiming",SWIGTYPE_p_defiIOTiming,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetIOTimingCbk) void register_defrSetIOTimingCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetIOTimingCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetIOTimingCbk)Tcl_DecrRefCount(TclCallBack_defrSetIOTimingCbk);
    TclCallBack_defrSetIOTimingCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetIOTimingCbk(_cbwrap_defrSetIOTimingCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetIOTimingsStartCbk=0;
 int _cbwrap_defrSetIOTimingsStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetIOTimingsStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetIOTimingsStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetIOTimingsStartCbk) void register_defrSetIOTimingsStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetIOTimingsStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetIOTimingsStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetIOTimingsStartCbk);
    TclCallBack_defrSetIOTimingsStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetIOTimingsStartCbk(_cbwrap_defrSetIOTimingsStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetIOTimingsEndCbk=0;
 int _cbwrap_defrSetIOTimingsEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetIOTimingsEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetIOTimingsEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetIOTimingsEndCbk) void register_defrSetIOTimingsEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetIOTimingsEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetIOTimingsEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetIOTimingsEndCbk);
    TclCallBack_defrSetIOTimingsEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetIOTimingsEndCbk(_cbwrap_defrSetIOTimingsEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetIoTimingsExtCbk=0;
 int _cbwrap_defrSetIoTimingsExtCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetIoTimingsExtCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetIoTimingsExtCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetIoTimingsExtCbk) void register_defrSetIoTimingsExtCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetIoTimingsExtCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetIoTimingsExtCbk)Tcl_DecrRefCount(TclCallBack_defrSetIoTimingsExtCbk);
    TclCallBack_defrSetIoTimingsExtCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetIoTimingsExtCbk(_cbwrap_defrSetIoTimingsExtCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetNetCbk=0;
 int _cbwrap_defrSetNetCbk(defrCallbackType_e cbkType,defiNet * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetNetCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetNetCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiNet",SWIGTYPE_p_defiNet,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetNetCbk) void register_defrSetNetCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetNetCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetNetCbk)Tcl_DecrRefCount(TclCallBack_defrSetNetCbk);
    TclCallBack_defrSetNetCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetNetCbk(_cbwrap_defrSetNetCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetNetNameCbk=0;
 int _cbwrap_defrSetNetNameCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetNetNameCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetNetNameCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetNetNameCbk) void register_defrSetNetNameCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetNetNameCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetNetNameCbk)Tcl_DecrRefCount(TclCallBack_defrSetNetNameCbk);
    TclCallBack_defrSetNetNameCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetNetNameCbk(_cbwrap_defrSetNetNameCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetNetNonDefaultRuleCbk=0;
 int _cbwrap_defrSetNetNonDefaultRuleCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetNetNonDefaultRuleCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetNetNonDefaultRuleCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetNetNonDefaultRuleCbk) void register_defrSetNetNonDefaultRuleCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetNetNonDefaultRuleCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetNetNonDefaultRuleCbk)Tcl_DecrRefCount(TclCallBack_defrSetNetNonDefaultRuleCbk);
    TclCallBack_defrSetNetNonDefaultRuleCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetNetNonDefaultRuleCbk(_cbwrap_defrSetNetNonDefaultRuleCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetNetConnectionExtCbk=0;
 int _cbwrap_defrSetNetConnectionExtCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetNetConnectionExtCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetNetConnectionExtCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetNetConnectionExtCbk) void register_defrSetNetConnectionExtCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetNetConnectionExtCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetNetConnectionExtCbk)Tcl_DecrRefCount(TclCallBack_defrSetNetConnectionExtCbk);
    TclCallBack_defrSetNetConnectionExtCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetNetConnectionExtCbk(_cbwrap_defrSetNetConnectionExtCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetNetExtCbk=0;
 int _cbwrap_defrSetNetExtCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetNetExtCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetNetExtCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetNetExtCbk) void register_defrSetNetExtCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetNetExtCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetNetExtCbk)Tcl_DecrRefCount(TclCallBack_defrSetNetExtCbk);
    TclCallBack_defrSetNetExtCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetNetExtCbk(_cbwrap_defrSetNetExtCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetNetPartialPathCbk=0;
 int _cbwrap_defrSetNetPartialPathCbk(defrCallbackType_e cbkType,defiNet * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetNetPartialPathCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetNetPartialPathCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiNet",SWIGTYPE_p_defiNet,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetNetPartialPathCbk) void register_defrSetNetPartialPathCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetNetPartialPathCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetNetPartialPathCbk)Tcl_DecrRefCount(TclCallBack_defrSetNetPartialPathCbk);
    TclCallBack_defrSetNetPartialPathCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetNetPartialPathCbk(_cbwrap_defrSetNetPartialPathCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetNetSubnetNameCbk=0;
 int _cbwrap_defrSetNetSubnetNameCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetNetSubnetNameCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetNetSubnetNameCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetNetSubnetNameCbk) void register_defrSetNetSubnetNameCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetNetSubnetNameCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetNetSubnetNameCbk)Tcl_DecrRefCount(TclCallBack_defrSetNetSubnetNameCbk);
    TclCallBack_defrSetNetSubnetNameCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetNetSubnetNameCbk(_cbwrap_defrSetNetSubnetNameCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetNetStartCbk=0;
 int _cbwrap_defrSetNetStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetNetStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetNetStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetNetStartCbk) void register_defrSetNetStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetNetStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetNetStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetNetStartCbk);
    TclCallBack_defrSetNetStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetNetStartCbk(_cbwrap_defrSetNetStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetNetEndCbk=0;
 int _cbwrap_defrSetNetEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetNetEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetNetEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetNetEndCbk) void register_defrSetNetEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetNetEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetNetEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetNetEndCbk);
    TclCallBack_defrSetNetEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetNetEndCbk(_cbwrap_defrSetNetEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetNonDefaultCbk=0;
 int _cbwrap_defrSetNonDefaultCbk(defrCallbackType_e cbkType,defiNonDefault * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetNonDefaultCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetNonDefaultCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiNonDefault",SWIGTYPE_p_defiNonDefault,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetNonDefaultCbk) void register_defrSetNonDefaultCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetNonDefaultCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetNonDefaultCbk)Tcl_DecrRefCount(TclCallBack_defrSetNonDefaultCbk);
    TclCallBack_defrSetNonDefaultCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetNonDefaultCbk(_cbwrap_defrSetNonDefaultCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetNonDefaultStartCbk=0;
 int _cbwrap_defrSetNonDefaultStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetNonDefaultStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetNonDefaultStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetNonDefaultStartCbk) void register_defrSetNonDefaultStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetNonDefaultStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetNonDefaultStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetNonDefaultStartCbk);
    TclCallBack_defrSetNonDefaultStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetNonDefaultStartCbk(_cbwrap_defrSetNonDefaultStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetNonDefaultEndCbk=0;
 int _cbwrap_defrSetNonDefaultEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetNonDefaultEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetNonDefaultEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetNonDefaultEndCbk) void register_defrSetNonDefaultEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetNonDefaultEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetNonDefaultEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetNonDefaultEndCbk);
    TclCallBack_defrSetNonDefaultEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetNonDefaultEndCbk(_cbwrap_defrSetNonDefaultEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetPartitionCbk=0;
 int _cbwrap_defrSetPartitionCbk(defrCallbackType_e cbkType,defiPartition * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetPartitionCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetPartitionCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiPartition",SWIGTYPE_p_defiPartition,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetPartitionCbk) void register_defrSetPartitionCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetPartitionCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetPartitionCbk)Tcl_DecrRefCount(TclCallBack_defrSetPartitionCbk);
    TclCallBack_defrSetPartitionCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetPartitionCbk(_cbwrap_defrSetPartitionCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetPartitionsExtCbk=0;
 int _cbwrap_defrSetPartitionsExtCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetPartitionsExtCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetPartitionsExtCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetPartitionsExtCbk) void register_defrSetPartitionsExtCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetPartitionsExtCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetPartitionsExtCbk)Tcl_DecrRefCount(TclCallBack_defrSetPartitionsExtCbk);
    TclCallBack_defrSetPartitionsExtCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetPartitionsExtCbk(_cbwrap_defrSetPartitionsExtCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetPartitionsStartCbk=0;
 int _cbwrap_defrSetPartitionsStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetPartitionsStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetPartitionsStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetPartitionsStartCbk) void register_defrSetPartitionsStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetPartitionsStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetPartitionsStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetPartitionsStartCbk);
    TclCallBack_defrSetPartitionsStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetPartitionsStartCbk(_cbwrap_defrSetPartitionsStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetPartitionsEndCbk=0;
 int _cbwrap_defrSetPartitionsEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetPartitionsEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetPartitionsEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetPartitionsEndCbk) void register_defrSetPartitionsEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetPartitionsEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetPartitionsEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetPartitionsEndCbk);
    TclCallBack_defrSetPartitionsEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetPartitionsEndCbk(_cbwrap_defrSetPartitionsEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetPathCbk=0;
 int _cbwrap_defrSetPathCbk(defrCallbackType_e cbkType,defiPath * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetPathCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetPathCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiPath",SWIGTYPE_p_defiPath,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetPathCbk) void register_defrSetPathCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetPathCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetPathCbk)Tcl_DecrRefCount(TclCallBack_defrSetPathCbk);
    TclCallBack_defrSetPathCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetPathCbk(_cbwrap_defrSetPathCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetPinCapCbk=0;
 int _cbwrap_defrSetPinCapCbk(defrCallbackType_e cbkType,defiPinCap * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetPinCapCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetPinCapCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiPinCap",SWIGTYPE_p_defiPinCap,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetPinCapCbk) void register_defrSetPinCapCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetPinCapCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetPinCapCbk)Tcl_DecrRefCount(TclCallBack_defrSetPinCapCbk);
    TclCallBack_defrSetPinCapCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetPinCapCbk(_cbwrap_defrSetPinCapCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetPinCbk=0;
 int _cbwrap_defrSetPinCbk(defrCallbackType_e cbkType,defiPin * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetPinCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetPinCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiPin",SWIGTYPE_p_defiPin,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetPinCbk) void register_defrSetPinCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetPinCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetPinCbk)Tcl_DecrRefCount(TclCallBack_defrSetPinCbk);
    TclCallBack_defrSetPinCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetPinCbk(_cbwrap_defrSetPinCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetPinExtCbk=0;
 int _cbwrap_defrSetPinExtCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetPinExtCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetPinExtCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetPinExtCbk) void register_defrSetPinExtCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetPinExtCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetPinExtCbk)Tcl_DecrRefCount(TclCallBack_defrSetPinExtCbk);
    TclCallBack_defrSetPinExtCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetPinExtCbk(_cbwrap_defrSetPinExtCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetPinPropCbk=0;
 int _cbwrap_defrSetPinPropCbk(defrCallbackType_e cbkType,defiPinProp * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetPinPropCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetPinPropCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiPinProp",SWIGTYPE_p_defiPinProp,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetPinPropCbk) void register_defrSetPinPropCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetPinPropCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetPinPropCbk)Tcl_DecrRefCount(TclCallBack_defrSetPinPropCbk);
    TclCallBack_defrSetPinPropCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetPinPropCbk(_cbwrap_defrSetPinPropCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetPinPropStartCbk=0;
 int _cbwrap_defrSetPinPropStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetPinPropStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetPinPropStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetPinPropStartCbk) void register_defrSetPinPropStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetPinPropStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetPinPropStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetPinPropStartCbk);
    TclCallBack_defrSetPinPropStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetPinPropStartCbk(_cbwrap_defrSetPinPropStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetPinPropEndCbk=0;
 int _cbwrap_defrSetPinPropEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetPinPropEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetPinPropEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetPinPropEndCbk) void register_defrSetPinPropEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetPinPropEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetPinPropEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetPinPropEndCbk);
    TclCallBack_defrSetPinPropEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetPinPropEndCbk(_cbwrap_defrSetPinPropEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetPropCbk=0;
 int _cbwrap_defrSetPropCbk(defrCallbackType_e cbkType,defiProp * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetPropCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetPropCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiProp",SWIGTYPE_p_defiProp,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetPropCbk) void register_defrSetPropCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetPropCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetPropCbk)Tcl_DecrRefCount(TclCallBack_defrSetPropCbk);
    TclCallBack_defrSetPropCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetPropCbk(_cbwrap_defrSetPropCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetPropDefEndCbk=0;
 int _cbwrap_defrSetPropDefEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetPropDefEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetPropDefEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetPropDefEndCbk) void register_defrSetPropDefEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetPropDefEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetPropDefEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetPropDefEndCbk);
    TclCallBack_defrSetPropDefEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetPropDefEndCbk(_cbwrap_defrSetPropDefEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetPropDefStartCbk=0;
 int _cbwrap_defrSetPropDefStartCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetPropDefStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetPropDefStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetPropDefStartCbk) void register_defrSetPropDefStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetPropDefStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetPropDefStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetPropDefStartCbk);
    TclCallBack_defrSetPropDefStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetPropDefStartCbk(_cbwrap_defrSetPropDefStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetRegionCbk=0;
 int _cbwrap_defrSetRegionCbk(defrCallbackType_e cbkType,defiRegion * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetRegionCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetRegionCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiRegion",SWIGTYPE_p_defiRegion,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetRegionCbk) void register_defrSetRegionCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetRegionCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetRegionCbk)Tcl_DecrRefCount(TclCallBack_defrSetRegionCbk);
    TclCallBack_defrSetRegionCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetRegionCbk(_cbwrap_defrSetRegionCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetRegionStartCbk=0;
 int _cbwrap_defrSetRegionStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetRegionStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetRegionStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetRegionStartCbk) void register_defrSetRegionStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetRegionStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetRegionStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetRegionStartCbk);
    TclCallBack_defrSetRegionStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetRegionStartCbk(_cbwrap_defrSetRegionStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetRegionEndCbk=0;
 int _cbwrap_defrSetRegionEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetRegionEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetRegionEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetRegionEndCbk) void register_defrSetRegionEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetRegionEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetRegionEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetRegionEndCbk);
    TclCallBack_defrSetRegionEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetRegionEndCbk(_cbwrap_defrSetRegionEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetRowCbk=0;
 int _cbwrap_defrSetRowCbk(defrCallbackType_e cbkType,defiRow * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetRowCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetRowCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiRow",SWIGTYPE_p_defiRow,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetRowCbk) void register_defrSetRowCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetRowCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetRowCbk)Tcl_DecrRefCount(TclCallBack_defrSetRowCbk);
    TclCallBack_defrSetRowCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetRowCbk(_cbwrap_defrSetRowCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetSNetCbk=0;
 int _cbwrap_defrSetSNetCbk(defrCallbackType_e cbkType,defiNet * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetSNetCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetSNetCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiNet",SWIGTYPE_p_defiNet,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetSNetCbk) void register_defrSetSNetCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetSNetCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetSNetCbk)Tcl_DecrRefCount(TclCallBack_defrSetSNetCbk);
    TclCallBack_defrSetSNetCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetSNetCbk(_cbwrap_defrSetSNetCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetSNetStartCbk=0;
 int _cbwrap_defrSetSNetStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetSNetStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetSNetStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetSNetStartCbk) void register_defrSetSNetStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetSNetStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetSNetStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetSNetStartCbk);
    TclCallBack_defrSetSNetStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetSNetStartCbk(_cbwrap_defrSetSNetStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetSNetEndCbk=0;
 int _cbwrap_defrSetSNetEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetSNetEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetSNetEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetSNetEndCbk) void register_defrSetSNetEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetSNetEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetSNetEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetSNetEndCbk);
    TclCallBack_defrSetSNetEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetSNetEndCbk(_cbwrap_defrSetSNetEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetSNetPartialPathCbk=0;
 int _cbwrap_defrSetSNetPartialPathCbk(defrCallbackType_e cbkType,defiNet * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetSNetPartialPathCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetSNetPartialPathCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiNet",SWIGTYPE_p_defiNet,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetSNetPartialPathCbk) void register_defrSetSNetPartialPathCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetSNetPartialPathCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetSNetPartialPathCbk)Tcl_DecrRefCount(TclCallBack_defrSetSNetPartialPathCbk);
    TclCallBack_defrSetSNetPartialPathCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetSNetPartialPathCbk(_cbwrap_defrSetSNetPartialPathCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetSNetWireCbk=0;
 int _cbwrap_defrSetSNetWireCbk(defrCallbackType_e cbkType,defiNet * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetSNetWireCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetSNetWireCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiNet",SWIGTYPE_p_defiNet,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetSNetWireCbk) void register_defrSetSNetWireCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetSNetWireCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetSNetWireCbk)Tcl_DecrRefCount(TclCallBack_defrSetSNetWireCbk);
    TclCallBack_defrSetSNetWireCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetSNetWireCbk(_cbwrap_defrSetSNetWireCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetScanChainExtCbk=0;
 int _cbwrap_defrSetScanChainExtCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetScanChainExtCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetScanChainExtCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetScanChainExtCbk) void register_defrSetScanChainExtCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetScanChainExtCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetScanChainExtCbk)Tcl_DecrRefCount(TclCallBack_defrSetScanChainExtCbk);
    TclCallBack_defrSetScanChainExtCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetScanChainExtCbk(_cbwrap_defrSetScanChainExtCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetScanchainCbk=0;
 int _cbwrap_defrSetScanchainCbk(defrCallbackType_e cbkType,defiScanchain * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetScanchainCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetScanchainCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiScanchain",SWIGTYPE_p_defiScanchain,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetScanchainCbk) void register_defrSetScanchainCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetScanchainCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetScanchainCbk)Tcl_DecrRefCount(TclCallBack_defrSetScanchainCbk);
    TclCallBack_defrSetScanchainCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetScanchainCbk(_cbwrap_defrSetScanchainCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetScanchainsStartCbk=0;
 int _cbwrap_defrSetScanchainsStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetScanchainsStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetScanchainsStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetScanchainsStartCbk) void register_defrSetScanchainsStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetScanchainsStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetScanchainsStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetScanchainsStartCbk);
    TclCallBack_defrSetScanchainsStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetScanchainsStartCbk(_cbwrap_defrSetScanchainsStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetScanchainsEndCbk=0;
 int _cbwrap_defrSetScanchainsEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetScanchainsEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetScanchainsEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetScanchainsEndCbk) void register_defrSetScanchainsEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetScanchainsEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetScanchainsEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetScanchainsEndCbk);
    TclCallBack_defrSetScanchainsEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetScanchainsEndCbk(_cbwrap_defrSetScanchainsEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetSiteCbk=0;
 int _cbwrap_defrSetSiteCbk(defrCallbackType_e cbkType,defiSite * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetSiteCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetSiteCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiSite",SWIGTYPE_p_defiSite,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetSiteCbk) void register_defrSetSiteCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetSiteCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetSiteCbk)Tcl_DecrRefCount(TclCallBack_defrSetSiteCbk);
    TclCallBack_defrSetSiteCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetSiteCbk(_cbwrap_defrSetSiteCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetSlotCbk=0;
 int _cbwrap_defrSetSlotCbk(defrCallbackType_e cbkType,defiSlot * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetSlotCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetSlotCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiSlot",SWIGTYPE_p_defiSlot,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetSlotCbk) void register_defrSetSlotCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetSlotCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetSlotCbk)Tcl_DecrRefCount(TclCallBack_defrSetSlotCbk);
    TclCallBack_defrSetSlotCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetSlotCbk(_cbwrap_defrSetSlotCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetSlotStartCbk=0;
 int _cbwrap_defrSetSlotStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetSlotStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetSlotStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetSlotStartCbk) void register_defrSetSlotStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetSlotStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetSlotStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetSlotStartCbk);
    TclCallBack_defrSetSlotStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetSlotStartCbk(_cbwrap_defrSetSlotStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetSlotEndCbk=0;
 int _cbwrap_defrSetSlotEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetSlotEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetSlotEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetSlotEndCbk) void register_defrSetSlotEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetSlotEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetSlotEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetSlotEndCbk);
    TclCallBack_defrSetSlotEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetSlotEndCbk(_cbwrap_defrSetSlotEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetStartPinsCbk=0;
 int _cbwrap_defrSetStartPinsCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetStartPinsCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetStartPinsCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetStartPinsCbk) void register_defrSetStartPinsCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetStartPinsCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetStartPinsCbk)Tcl_DecrRefCount(TclCallBack_defrSetStartPinsCbk);
    TclCallBack_defrSetStartPinsCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetStartPinsCbk(_cbwrap_defrSetStartPinsCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetStylesCbk=0;
 int _cbwrap_defrSetStylesCbk(defrCallbackType_e cbkType,defiStyles * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetStylesCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetStylesCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiStyles",SWIGTYPE_p_defiStyles,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetStylesCbk) void register_defrSetStylesCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetStylesCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetStylesCbk)Tcl_DecrRefCount(TclCallBack_defrSetStylesCbk);
    TclCallBack_defrSetStylesCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetStylesCbk(_cbwrap_defrSetStylesCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetStylesStartCbk=0;
 int _cbwrap_defrSetStylesStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetStylesStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetStylesStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetStylesStartCbk) void register_defrSetStylesStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetStylesStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetStylesStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetStylesStartCbk);
    TclCallBack_defrSetStylesStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetStylesStartCbk(_cbwrap_defrSetStylesStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetStylesEndCbk=0;
 int _cbwrap_defrSetStylesEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetStylesEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetStylesEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetStylesEndCbk) void register_defrSetStylesEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetStylesEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetStylesEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetStylesEndCbk);
    TclCallBack_defrSetStylesEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetStylesEndCbk(_cbwrap_defrSetStylesEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetPinEndCbk=0;
 int _cbwrap_defrSetPinEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetPinEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetPinEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetPinEndCbk) void register_defrSetPinEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetPinEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetPinEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetPinEndCbk);
    TclCallBack_defrSetPinEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetPinEndCbk(_cbwrap_defrSetPinEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetTechnologyCbk=0;
 int _cbwrap_defrSetTechnologyCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetTechnologyCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetTechnologyCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetTechnologyCbk) void register_defrSetTechnologyCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetTechnologyCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetTechnologyCbk)Tcl_DecrRefCount(TclCallBack_defrSetTechnologyCbk);
    TclCallBack_defrSetTechnologyCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetTechnologyCbk(_cbwrap_defrSetTechnologyCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetTimingDisableCbk=0;
 int _cbwrap_defrSetTimingDisableCbk(defrCallbackType_e cbkType,defiTimingDisable * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetTimingDisableCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetTimingDisableCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiTimingDisable",SWIGTYPE_p_defiTimingDisable,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetTimingDisableCbk) void register_defrSetTimingDisableCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetTimingDisableCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetTimingDisableCbk)Tcl_DecrRefCount(TclCallBack_defrSetTimingDisableCbk);
    TclCallBack_defrSetTimingDisableCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetTimingDisableCbk(_cbwrap_defrSetTimingDisableCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetTimingDisablesStartCbk=0;
 int _cbwrap_defrSetTimingDisablesStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetTimingDisablesStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetTimingDisablesStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetTimingDisablesStartCbk) void register_defrSetTimingDisablesStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetTimingDisablesStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetTimingDisablesStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetTimingDisablesStartCbk);
    TclCallBack_defrSetTimingDisablesStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetTimingDisablesStartCbk(_cbwrap_defrSetTimingDisablesStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetTimingDisablesEndCbk=0;
 int _cbwrap_defrSetTimingDisablesEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetTimingDisablesEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetTimingDisablesEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetTimingDisablesEndCbk) void register_defrSetTimingDisablesEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetTimingDisablesEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetTimingDisablesEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetTimingDisablesEndCbk);
    TclCallBack_defrSetTimingDisablesEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetTimingDisablesEndCbk(_cbwrap_defrSetTimingDisablesEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetTrackCbk=0;
 int _cbwrap_defrSetTrackCbk(defrCallbackType_e cbkType,defiTrack * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetTrackCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetTrackCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiTrack",SWIGTYPE_p_defiTrack,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetTrackCbk) void register_defrSetTrackCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetTrackCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetTrackCbk)Tcl_DecrRefCount(TclCallBack_defrSetTrackCbk);
    TclCallBack_defrSetTrackCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetTrackCbk(_cbwrap_defrSetTrackCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetUnitsCbk=0;
 int _cbwrap_defrSetUnitsCbk(defrCallbackType_e cbkType,double  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetUnitsCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetUnitsCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_double((double)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetUnitsCbk) void register_defrSetUnitsCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetUnitsCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetUnitsCbk)Tcl_DecrRefCount(TclCallBack_defrSetUnitsCbk);
    TclCallBack_defrSetUnitsCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetUnitsCbk(_cbwrap_defrSetUnitsCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetVersionCbk=0;
 int _cbwrap_defrSetVersionCbk(defrCallbackType_e cbkType,double  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetVersionCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetVersionCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_double((double)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetVersionCbk) void register_defrSetVersionCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetVersionCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetVersionCbk)Tcl_DecrRefCount(TclCallBack_defrSetVersionCbk);
    TclCallBack_defrSetVersionCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetVersionCbk(_cbwrap_defrSetVersionCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetVersionStrCbk=0;
 int _cbwrap_defrSetVersionStrCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetVersionStrCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetVersionStrCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetVersionStrCbk) void register_defrSetVersionStrCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetVersionStrCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetVersionStrCbk)Tcl_DecrRefCount(TclCallBack_defrSetVersionStrCbk);
    TclCallBack_defrSetVersionStrCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetVersionStrCbk(_cbwrap_defrSetVersionStrCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetViaCbk=0;
 int _cbwrap_defrSetViaCbk(defrCallbackType_e cbkType,defiVia * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetViaCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetViaCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    Tcl_Obj *newObj=SWIG_Ptr2Obj(interp,"defiVia",SWIGTYPE_p_defiVia,_arg2);
    arg1= newObj;
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetViaCbk) void register_defrSetViaCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetViaCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetViaCbk)Tcl_DecrRefCount(TclCallBack_defrSetViaCbk);
    TclCallBack_defrSetViaCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetViaCbk(_cbwrap_defrSetViaCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetViaExtCbk=0;
 int _cbwrap_defrSetViaExtCbk(defrCallbackType_e cbkType,const char * _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetViaExtCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetViaExtCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_FromCharPtr((const char *)_arg2);
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetViaExtCbk) void register_defrSetViaExtCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetViaExtCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetViaExtCbk)Tcl_DecrRefCount(TclCallBack_defrSetViaExtCbk);
    TclCallBack_defrSetViaExtCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetViaExtCbk(_cbwrap_defrSetViaExtCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetViaStartCbk=0;
 int _cbwrap_defrSetViaStartCbk(defrCallbackType_e cbkType,int  _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetViaStartCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetViaStartCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  arg1=SWIG_From_int((int)(_arg2));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetViaStartCbk) void register_defrSetViaStartCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetViaStartCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetViaStartCbk)Tcl_DecrRefCount(TclCallBack_defrSetViaStartCbk);
    TclCallBack_defrSetViaStartCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetViaStartCbk(_cbwrap_defrSetViaStartCbk);
%}

%{
static Tcl_Obj* TclCallBack_defrSetViaEndCbk=0;
 int _cbwrap_defrSetViaEndCbk(defrCallbackType_e cbkType,void* _arg2,defiUserData userData){

    Tcl_Obj *arg0, *arg1, *arg2;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defrSetViaEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defrSetViaEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(_arg2)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)_arg2;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg2);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defrSetViaEndCbk) void register_defrSetViaEndCbk(Tcl_Obj *pyfunc);
%{
void register_defrSetViaEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defrSetViaEndCbk)Tcl_DecrRefCount(TclCallBack_defrSetViaEndCbk);
    TclCallBack_defrSetViaEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defrSetViaEndCbk(_cbwrap_defrSetViaEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetArrayCbk=0;
 int _cbwrap_defwSetArrayCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetArrayCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetArrayCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetArrayCbk) void register_defwSetArrayCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetArrayCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetArrayCbk)Tcl_DecrRefCount(TclCallBack_defwSetArrayCbk);
    TclCallBack_defwSetArrayCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetArrayCbk(_cbwrap_defwSetArrayCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetAssertionCbk=0;
 int _cbwrap_defwSetAssertionCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetAssertionCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetAssertionCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetAssertionCbk) void register_defwSetAssertionCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetAssertionCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetAssertionCbk)Tcl_DecrRefCount(TclCallBack_defwSetAssertionCbk);
    TclCallBack_defwSetAssertionCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetAssertionCbk(_cbwrap_defwSetAssertionCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetBlockageCbk=0;
 int _cbwrap_defwSetBlockageCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetBlockageCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetBlockageCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetBlockageCbk) void register_defwSetBlockageCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetBlockageCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetBlockageCbk)Tcl_DecrRefCount(TclCallBack_defwSetBlockageCbk);
    TclCallBack_defwSetBlockageCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetBlockageCbk(_cbwrap_defwSetBlockageCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetBusBitCbk=0;
 int _cbwrap_defwSetBusBitCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetBusBitCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetBusBitCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetBusBitCbk) void register_defwSetBusBitCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetBusBitCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetBusBitCbk)Tcl_DecrRefCount(TclCallBack_defwSetBusBitCbk);
    TclCallBack_defwSetBusBitCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetBusBitCbk(_cbwrap_defwSetBusBitCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetCannotOccupyCbk=0;
 int _cbwrap_defwSetCannotOccupyCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetCannotOccupyCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetCannotOccupyCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetCannotOccupyCbk) void register_defwSetCannotOccupyCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetCannotOccupyCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetCannotOccupyCbk)Tcl_DecrRefCount(TclCallBack_defwSetCannotOccupyCbk);
    TclCallBack_defwSetCannotOccupyCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetCannotOccupyCbk(_cbwrap_defwSetCannotOccupyCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetCanplaceCbk=0;
 int _cbwrap_defwSetCanplaceCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetCanplaceCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetCanplaceCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetCanplaceCbk) void register_defwSetCanplaceCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetCanplaceCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetCanplaceCbk)Tcl_DecrRefCount(TclCallBack_defwSetCanplaceCbk);
    TclCallBack_defwSetCanplaceCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetCanplaceCbk(_cbwrap_defwSetCanplaceCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetCaseSensitiveCbk=0;
 int _cbwrap_defwSetCaseSensitiveCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetCaseSensitiveCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetCaseSensitiveCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetCaseSensitiveCbk) void register_defwSetCaseSensitiveCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetCaseSensitiveCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetCaseSensitiveCbk)Tcl_DecrRefCount(TclCallBack_defwSetCaseSensitiveCbk);
    TclCallBack_defwSetCaseSensitiveCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetCaseSensitiveCbk(_cbwrap_defwSetCaseSensitiveCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetComponentCbk=0;
 int _cbwrap_defwSetComponentCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetComponentCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetComponentCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetComponentCbk) void register_defwSetComponentCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetComponentCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetComponentCbk)Tcl_DecrRefCount(TclCallBack_defwSetComponentCbk);
    TclCallBack_defwSetComponentCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetComponentCbk(_cbwrap_defwSetComponentCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetConstraintCbk=0;
 int _cbwrap_defwSetConstraintCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetConstraintCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetConstraintCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetConstraintCbk) void register_defwSetConstraintCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetConstraintCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetConstraintCbk)Tcl_DecrRefCount(TclCallBack_defwSetConstraintCbk);
    TclCallBack_defwSetConstraintCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetConstraintCbk(_cbwrap_defwSetConstraintCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetDefaultCapCbk=0;
 int _cbwrap_defwSetDefaultCapCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetDefaultCapCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetDefaultCapCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetDefaultCapCbk) void register_defwSetDefaultCapCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetDefaultCapCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetDefaultCapCbk)Tcl_DecrRefCount(TclCallBack_defwSetDefaultCapCbk);
    TclCallBack_defwSetDefaultCapCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetDefaultCapCbk(_cbwrap_defwSetDefaultCapCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetDesignCbk=0;
 int _cbwrap_defwSetDesignCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetDesignCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetDesignCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetDesignCbk) void register_defwSetDesignCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetDesignCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetDesignCbk)Tcl_DecrRefCount(TclCallBack_defwSetDesignCbk);
    TclCallBack_defwSetDesignCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetDesignCbk(_cbwrap_defwSetDesignCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetDesignEndCbk=0;
 int _cbwrap_defwSetDesignEndCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetDesignEndCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetDesignEndCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetDesignEndCbk) void register_defwSetDesignEndCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetDesignEndCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetDesignEndCbk)Tcl_DecrRefCount(TclCallBack_defwSetDesignEndCbk);
    TclCallBack_defwSetDesignEndCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetDesignEndCbk(_cbwrap_defwSetDesignEndCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetDieAreaCbk=0;
 int _cbwrap_defwSetDieAreaCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetDieAreaCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetDieAreaCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetDieAreaCbk) void register_defwSetDieAreaCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetDieAreaCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetDieAreaCbk)Tcl_DecrRefCount(TclCallBack_defwSetDieAreaCbk);
    TclCallBack_defwSetDieAreaCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetDieAreaCbk(_cbwrap_defwSetDieAreaCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetDividerCbk=0;
 int _cbwrap_defwSetDividerCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetDividerCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetDividerCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetDividerCbk) void register_defwSetDividerCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetDividerCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetDividerCbk)Tcl_DecrRefCount(TclCallBack_defwSetDividerCbk);
    TclCallBack_defwSetDividerCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetDividerCbk(_cbwrap_defwSetDividerCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetExtCbk=0;
 int _cbwrap_defwSetExtCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetExtCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetExtCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetExtCbk) void register_defwSetExtCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetExtCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetExtCbk)Tcl_DecrRefCount(TclCallBack_defwSetExtCbk);
    TclCallBack_defwSetExtCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetExtCbk(_cbwrap_defwSetExtCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetFloorPlanCbk=0;
 int _cbwrap_defwSetFloorPlanCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetFloorPlanCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetFloorPlanCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetFloorPlanCbk) void register_defwSetFloorPlanCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetFloorPlanCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetFloorPlanCbk)Tcl_DecrRefCount(TclCallBack_defwSetFloorPlanCbk);
    TclCallBack_defwSetFloorPlanCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetFloorPlanCbk(_cbwrap_defwSetFloorPlanCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetGcellGridCbk=0;
 int _cbwrap_defwSetGcellGridCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetGcellGridCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetGcellGridCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetGcellGridCbk) void register_defwSetGcellGridCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetGcellGridCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetGcellGridCbk)Tcl_DecrRefCount(TclCallBack_defwSetGcellGridCbk);
    TclCallBack_defwSetGcellGridCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetGcellGridCbk(_cbwrap_defwSetGcellGridCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetGroupCbk=0;
 int _cbwrap_defwSetGroupCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetGroupCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetGroupCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetGroupCbk) void register_defwSetGroupCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetGroupCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetGroupCbk)Tcl_DecrRefCount(TclCallBack_defwSetGroupCbk);
    TclCallBack_defwSetGroupCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetGroupCbk(_cbwrap_defwSetGroupCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetHistoryCbk=0;
 int _cbwrap_defwSetHistoryCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetHistoryCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetHistoryCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetHistoryCbk) void register_defwSetHistoryCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetHistoryCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetHistoryCbk)Tcl_DecrRefCount(TclCallBack_defwSetHistoryCbk);
    TclCallBack_defwSetHistoryCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetHistoryCbk(_cbwrap_defwSetHistoryCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetIOTimingCbk=0;
 int _cbwrap_defwSetIOTimingCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetIOTimingCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetIOTimingCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetIOTimingCbk) void register_defwSetIOTimingCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetIOTimingCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetIOTimingCbk)Tcl_DecrRefCount(TclCallBack_defwSetIOTimingCbk);
    TclCallBack_defwSetIOTimingCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetIOTimingCbk(_cbwrap_defwSetIOTimingCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetNetCbk=0;
 int _cbwrap_defwSetNetCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetNetCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetNetCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetNetCbk) void register_defwSetNetCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetNetCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetNetCbk)Tcl_DecrRefCount(TclCallBack_defwSetNetCbk);
    TclCallBack_defwSetNetCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetNetCbk(_cbwrap_defwSetNetCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetPinCbk=0;
 int _cbwrap_defwSetPinCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetPinCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetPinCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetPinCbk) void register_defwSetPinCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetPinCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetPinCbk)Tcl_DecrRefCount(TclCallBack_defwSetPinCbk);
    TclCallBack_defwSetPinCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetPinCbk(_cbwrap_defwSetPinCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetPinPropCbk=0;
 int _cbwrap_defwSetPinPropCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetPinPropCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetPinPropCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetPinPropCbk) void register_defwSetPinPropCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetPinPropCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetPinPropCbk)Tcl_DecrRefCount(TclCallBack_defwSetPinPropCbk);
    TclCallBack_defwSetPinPropCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetPinPropCbk(_cbwrap_defwSetPinPropCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetPropDefCbk=0;
 int _cbwrap_defwSetPropDefCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetPropDefCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetPropDefCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetPropDefCbk) void register_defwSetPropDefCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetPropDefCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetPropDefCbk)Tcl_DecrRefCount(TclCallBack_defwSetPropDefCbk);
    TclCallBack_defwSetPropDefCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetPropDefCbk(_cbwrap_defwSetPropDefCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetRegionCbk=0;
 int _cbwrap_defwSetRegionCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetRegionCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetRegionCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetRegionCbk) void register_defwSetRegionCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetRegionCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetRegionCbk)Tcl_DecrRefCount(TclCallBack_defwSetRegionCbk);
    TclCallBack_defwSetRegionCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetRegionCbk(_cbwrap_defwSetRegionCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetRowCbk=0;
 int _cbwrap_defwSetRowCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetRowCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetRowCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetRowCbk) void register_defwSetRowCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetRowCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetRowCbk)Tcl_DecrRefCount(TclCallBack_defwSetRowCbk);
    TclCallBack_defwSetRowCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetRowCbk(_cbwrap_defwSetRowCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetSNetCbk=0;
 int _cbwrap_defwSetSNetCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetSNetCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetSNetCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetSNetCbk) void register_defwSetSNetCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetSNetCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetSNetCbk)Tcl_DecrRefCount(TclCallBack_defwSetSNetCbk);
    TclCallBack_defwSetSNetCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetSNetCbk(_cbwrap_defwSetSNetCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetScanchainCbk=0;
 int _cbwrap_defwSetScanchainCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetScanchainCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetScanchainCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetScanchainCbk) void register_defwSetScanchainCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetScanchainCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetScanchainCbk)Tcl_DecrRefCount(TclCallBack_defwSetScanchainCbk);
    TclCallBack_defwSetScanchainCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetScanchainCbk(_cbwrap_defwSetScanchainCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetTechnologyCbk=0;
 int _cbwrap_defwSetTechnologyCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetTechnologyCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetTechnologyCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetTechnologyCbk) void register_defwSetTechnologyCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetTechnologyCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetTechnologyCbk)Tcl_DecrRefCount(TclCallBack_defwSetTechnologyCbk);
    TclCallBack_defwSetTechnologyCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetTechnologyCbk(_cbwrap_defwSetTechnologyCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetTrackCbk=0;
 int _cbwrap_defwSetTrackCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetTrackCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetTrackCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetTrackCbk) void register_defwSetTrackCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetTrackCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetTrackCbk)Tcl_DecrRefCount(TclCallBack_defwSetTrackCbk);
    TclCallBack_defwSetTrackCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetTrackCbk(_cbwrap_defwSetTrackCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetUnitsCbk=0;
 int _cbwrap_defwSetUnitsCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetUnitsCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetUnitsCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetUnitsCbk) void register_defwSetUnitsCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetUnitsCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetUnitsCbk)Tcl_DecrRefCount(TclCallBack_defwSetUnitsCbk);
    TclCallBack_defwSetUnitsCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetUnitsCbk(_cbwrap_defwSetUnitsCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetVersionCbk=0;
 int _cbwrap_defwSetVersionCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetVersionCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetVersionCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetVersionCbk) void register_defwSetVersionCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetVersionCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetVersionCbk)Tcl_DecrRefCount(TclCallBack_defwSetVersionCbk);
    TclCallBack_defwSetVersionCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetVersionCbk(_cbwrap_defwSetVersionCbk);
%}

%{
static Tcl_Obj* TclCallBack_defwSetViaCbk=0;
 int _cbwrap_defwSetViaCbk(defwCallbackType_e cbkType,defiUserData userData){

    Tcl_Obj *arg0, *arg1;
    Tcl_Interp *interp=static_interp;
    Tcl_Obj *cmdPtr;

    if(!TclCallBack_defwSetViaCbk)return 0;
    cmdPtr=Tcl_DuplicateObj(TclCallBack_defwSetViaCbk);
    Tcl_IncrRefCount(cmdPtr);
  arg0=SWIG_From_int((int)(cbkType));
    Tcl_ListObjAppendElement(interp, cmdPtr, arg0);
  {
    if(userData)
    (Tcl_GetObjResult(interp))=(Tcl_Obj *)userData;
    else
    (Tcl_GetObjResult(interp))=Tcl_NewStringObj("",-1);
  }
    Tcl_ListObjAppendElement(interp, cmdPtr, arg1);

    if (Tcl_EvalObjEx(interp, cmdPtr, TCL_EVAL_GLOBAL) != TCL_OK) {
        Tcl_BackgroundError(interp);
    }
    { 
      Tcl_Obj *o=Tcl_GetObjResult(interp);
      Tcl_GetIntFromObj(interp,o,&ret);
    }
    Tcl_DecrRefCount(cmdPtr);
    return ret;
}
%}
%rename(defwSetViaCbk) void register_defwSetViaCbk(Tcl_Obj *pyfunc);
%{
void register_defwSetViaCbk(Tcl_Obj *tclfunc){
    if(TclCallBack_defwSetViaCbk)Tcl_DecrRefCount(TclCallBack_defwSetViaCbk);
    TclCallBack_defwSetViaCbk=tclfunc;
    Tcl_IncrRefCount(tclfunc);
}
%}

%init %{
    defwSetViaCbk(_cbwrap_defwSetViaCbk);
%}
